'use strict'

import axios from 'axios'
import qs from 'qs'
import { Message, MessageBox } from 'element-ui';
import zutil from './util.js';
import router from '@/router';

let BS_projectBaseUrl = '';
if (!zutil.mockFlag) {
  // 正式环境
  BS_projectBaseUrl = '';
}

// 状态码错误信息
const codeMessage = {
  200: '服务器成功返回请求的数据。',
  201: '新建或修改数据成功。',
  202: '一个请求已经进入后台排队（异步任务）。',
  204: '删除数据成功。',
  400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
  401: '用户没有权限（令牌、用户名、密码错误）。',
  403: '用户得到授权，但是访问是被禁止的。',
  404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
  406: '请求的格式不可得。',
  410: '请求的资源被永久删除，且不会再得到的。',
  422: '当创建一个对象时，发生一个验证错误。',
  500: '服务器发生错误，请检查服务器。',
  502: '网关错误。',
  503: '服务不可用，服务器暂时过载或维护。',
  504: '网关超时。',
};

axios.interceptors.request.use(config => {
  let loginUserInfo = zutil.lStorage.getParam('loginUserInfo');
  if(loginUserInfo){
    loginUserInfo = JSON.parse(loginUserInfo);
    config.headers.Authorization = `Token ${loginUserInfo.token}`;
  }
  // 请求开始
  return config;
}, error => {
  return Promise.reject(error)
})

axios.interceptors.response.use(
  response => {
    // 请求结束
    if (response && (response.status === 200 || response.status === 304 || response.status === 400)) {
      //登陆拦截
      if(response.data.stat ==1000000){
        Message.error(response.data.message || "登录状态失效");
        // router.push('/login')
      }
      return response;
    }else{
      Message.error(codeMessage[response.status] || "系统错误，请稍后再试！");
    }
  }, 
  error => {
    return Promise.resolve(error.response)
  }
)

function checkStatus (response) {
  // loading
  // 如果http状态码正常，则直接返回数据
  if (response && (response.status === 200 || response.status === 304 || response.status === 400)) {
    return response
    // 如果不需要除了data之外的数据，可以直接 return response.data
  }else if (response && (response.status === 401)) {
    //登陆拦截
    if(router.currentRoute.path == '/login'){
      return response;
    }else{
      let _msg = response.data.msg;
      if(response.data.errid == '2004')
        _msg = '登录失效，请重新登录';
      Message.error(_msg || codeMessage[response.status]);
      router.push('/login');
    }
  }else{
    // 异常状态下，把错误信息返回去
    response && Message.error((response.data.msg || response.data.detail || codeMessage[response.status]));
  }
}

function checkCode (res) {
  // 如果code异常(这里已经包括网络错误，服务器错误，后端抛出的错误)，可以弹出一个错误提示，告诉用户
  if(!res || !res.status){
    res = {
      status: '-9999',
      data: {
        state: '-9999'
      }
    }
  }
  if (res.status === 404) {
    // MessageBox.alert("404，网络异常");
    Message.error("404，网络异常");
  }
  return res
}

// 多个ajax请求同时发送

/*axios.all([
  axios.get('res/json/shangcheng/changsuo.json'),
  axios.get('res/json/shangcheng/fenlei.json')
])
.then(axios.spread((cs, fl)=> {
  // 上面两个请求都完成后，才执行这个回调方法
  let cssd = cs.data,
    fls = fl.data;
  console.log(cssd)
  if(cssd.code == '0000'){
    this.search.cs = cssd.data
  }
  if(fls.code == '0000'){
    this.search.fl = fls.data
  }
}));*/

function retNullVal(data, type){
  // 空值转为null
  let zdata = data;
  if(type && type == 2){
    zdata = zutil.getURLParameters(data);
  }
  for(var key in zdata){
    if(Object.prototype.toString.call(zdata[key]) === "[object String]")
      zdata[key] = zutil.trim(zdata[key]);
    if(zdata[key] == undefined || zdata[key] == 'undefined' || zdata[key] == null || zdata[key] == 'null' || (!Array.isArray(zdata[key]) && zdata[key].toString() == '') || zdata[key] === ''){
      zdata[key] = null;
      // zdata[key] = "";
    }else if(Array.isArray(zdata[key])){
      if(type && [1, 2].includes(type)){
        zdata[key] = zdata[key].join(",");
      }
    }
  }
  return zdata;
}

export default {
  post (url, data={}) {
    data = retNullVal(data);
    return axios({
      method: 'post',
      baseURL: BS_projectBaseUrl,
      url,
      // data: qs.stringify(data),
      data: data,
      timeout: 10000,
      dataType: "json",
      headers: {
        'X-Requested-With': 'XMLHttpRequest',
        // 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
        'Content-Type': 'application/json; charset=UTF-8'
      }
    }).then(
      (response) => {
        return checkStatus(response)
      }
    ).then(
      (res) => {
        return checkCode(res)
      }
    )
  },
  get (url, params={}) {
    let xparams = params;
    if(typeof params == 'string'){
      let _str1 = null,
        _str2 = null;
      if(params.indexOf("?") !== -1){
        _str1 = params.split("?")[0];
        _str2 = params.split("?")[1];
      }else{
        _str2 = params;
      }
      if(_str1)
        url = url+_str1;
      xparams = retNullVal(_str2, 2);
    }else if(params.zuiCusUrl){
      url += '/'+params.zuiCusUrl;
      xparams = retNullVal(params, 1);
    }else{
      xparams = retNullVal(params, 1);
    }
    return axios({
      method: 'get',
      baseURL: BS_projectBaseUrl,
      url,
      params: xparams, // get 请求时带的参数
      timeout: 10000,
      dataType: "json",
      headers: {
        'X-Requested-With': 'XMLHttpRequest',
        'Content-Type': 'application/json; charset=UTF-8'
      }
    }).then(
      (response) => {
        return checkStatus(response)
      }
    ).then(
      (res) => {
        return checkCode(res)
      }
    )
  },
  put (url, data={}) {
    data = retNullVal(data);
    if(data.zuiCusUrl){
      url += '/'+data.zuiCusUrl;
    }
    return axios({
      method: 'put',
      baseURL: BS_projectBaseUrl,
      url,
      data: data,
      timeout: 10000,
      dataType: "json",
      headers: {
        'X-Requested-With': 'XMLHttpRequest',
        'Content-Type': 'application/json; charset=UTF-8'
      }
    }).then(
      (response) => {
        return checkStatus(response)
      }
    ).then(
      (res) => {
        return checkCode(res)
      }
    )
  },
  delete (url, data={}) {
    data = retNullVal(data);
    if(data.zuiCusUrl){
      url += '/'+data.zuiCusUrl;
    }
    return axios({
      method: 'delete',
      baseURL: BS_projectBaseUrl,
      url,
      data: data,
      timeout: 10000,
      dataType: "json",
      headers: {
        'X-Requested-With': 'XMLHttpRequest',
        'Content-Type': 'application/json; charset=UTF-8'
      }
    }).then(
      (response) => {
        return checkStatus(response)
      }
    ).then(
      (res) => {
        return checkCode(res)
      }
    )
  }
}